using System;
using System.Collections.Generic;
using System.Text;
using NiSis.Entities;

namespace NiSis.Data
{
    public class MappingUtil
    {
        public static VList<VTradersPrec> MapRelazioniSocietarie(VList<VRelazioniSocietarie> rels)
        {
            VList<VTradersPrec> traders = new VList<VTradersPrec>();

            foreach (VRelazioniSocietarie rel in rels)
            {
                VTradersPrec tr = new VTradersPrec();
                tr.CdPool = rel.CdPool;
                tr.CdSocieta = rel.CdSocieta;
                tr.DsSocieta = string.Format("{0} (rel {1}-{2})",rel.DsSocieta,rel.CdSocieta1,rel.CdSocieta) ;
                tr.CdMeseInizioFornitura = rel.CdStoricoMensileRete;
                tr.Piva = string.Empty;
                traders.Add(tr);

            }
            return traders;
        }
        public static VList<VShipperAttiviPool> MapRelazioneSocietarieShippers(VList<VRelazioniSocietarie> rels)
        {
            VList<VShipperAttiviPool> shippers = new VList<VShipperAttiviPool>();
            foreach (VRelazioniSocietarie rel in rels)
            {
                VShipperAttiviPool sh = new VShipperAttiviPool();
                sh.CdPool = rel.CdPool;
                sh.CdSocieta = rel.CdSocieta;
                sh.DsSocieta = string.Format("{0} (rel {1}-{2})", rel.DsSocieta, rel.CdSocieta1, rel.CdSocieta);
                sh.CdStoricoMensileRete = rel.CdStoricoMensileRete;
                sh.Piva = string.Empty;

                shippers.Add(sh);
            }
            return shippers;
        }
        public static VList<VShipperAttiviPool> MapShipperDefault(VList<VShipperDefaultPool> sd)
        {
            VList<VShipperAttiviPool> shippers = new VList<VShipperAttiviPool>();
            foreach (VShipperDefaultPool s in sd)
            {
                VShipperAttiviPool sh = new VShipperAttiviPool();
                sh.CdPool = s.CdPool;
                sh.CdSocieta = s.CdSocieta;
                sh.DsSocieta = s.DsSocieta;
                sh.CdStoricoMensileRete = s.CdStoricoMensileRete;
                sh.Piva = string.Empty;

                shippers.Add(sh);

            }
            return shippers;

        }
        public static VList<VTradersPrec> MapTradersDefault(VList<VShipperDefaultPool> sd)
        {
            VList<VTradersPrec> traders = new VList<VTradersPrec>();
            foreach (VShipperDefaultPool s in sd)
            {
                VTradersPrec td = new VTradersPrec();
                td.CdPool = s.CdPool;
                td.CdSocieta = s.CdSocieta;
                td.DsSocieta = s.DsSocieta;
                td.CdMeseInizioFornitura = s.CdStoricoMensileRete;
                td.Piva = string.Empty;

                traders.Add(td);

            }
            return traders;

        }
        public static void MapUsersToSShTrader(SshTraderPrecStorico tps, VTradersPrec tp)
        {
            SshUtenzeGasStorico ut = new SshUtenzeGasStorico();
            ut.CdCliente = tp.CdCliente;
            ut.CdComune = tp.CdComune;
            ut.CdPrelievoAeeg = tp.CdPrelievoAeeg;
            ut.CdPuntoFornitura = tp.CdPuntoFornitura;
            ut.ConsumoAnnuoStimato = tp.ConsumoAnnuoStimato;
            ut.DsCliente = tp.DsCliente;
            ut.SAreaUscita = tp.SAreaUscita;
            ut.IdStato = (int)SshStatoRelazioniList.Ipotizzato;
            ut.CdAteco = tp.CdAteco;
            tps.SshUtenzeGasStoricoCollection.Add(ut);
            
        }
        public static void MapUsersToSShTrader(TList<SshTraderPrecStorico> traders, VList<VTradersPrec> tps)
        {
            foreach (SshTraderPrecStorico tr in traders)
            {
                VList<VTradersPrec> vt = tps.FindAll(VTradersPrecColumn.CdTraderPrecedente, tr.CdTraderPrecedente);
                vt = CustomUtil.SelectDistinctFromVList<VTradersPrec>(vt, new Enum[] { VTradersPrecColumn.CdCliente });
                foreach (VTradersPrec tp in vt)
                    MapUsersToSShTrader(tr, tp);
            }

        }
        public static SshSocietaStoricoChain MapVShippersAttivoToStorico(IShipperTraderPool shipper, SshBatchRelazioni rels)
        {
            SshSocietaStoricoChain StChain = new SshSocietaStoricoChain();
            StChain.CdSocieta = shipper.CdSocieta;
            StChain.FullDescription = String.Format("{0} (shipper)", shipper.DsSocieta);
            StChain.IdBatchRelazioni = rels.IdBatch;
            StChain.IdTipologiaSocieta = 2;
            StChain.RagioneSociale = shipper.DsSocieta;
            StChain.Piva = shipper.Piva;
            StChain.DtIns = DateTime.Now;
            return StChain;
        }
        public static TList<SshTraderPrecStorico> GetTradersPrecStorico(VList<VTradersPrec> tPrec)
        {
            TList<SshTraderPrecStorico> tStorico = new TList<SshTraderPrecStorico>();

            foreach (VTradersPrec tp in tPrec)
            {
           
                SshTraderPrecStorico tps = new SshTraderPrecStorico();
                tps.IdTipologia = (tp.TipologiaSocieta == "Trader") ? 1 : 2;
                tps.MeseInizioFornitura = tp.CdMeseInizioFornitura;
                tps.RagioneSociale = tp.DsSocieta;
                tps.CdTraderPrecedente = tp.CdTraderPrecedente;

                tStorico.Add(tps);
                
                
            }

            return tStorico;
        }
        public static VTradersPrec MapTpUserToTPrec(VTpUtenzeAll ut)
        {
            VTradersPrec t=new VTradersPrec();
            t.CdPool = ut.CdPool;
            t.CdSocieta = ut.CdCliente;
            t.DsSocieta = ut.RagioneSociale;
            t.CdCliente = ut.CdCliente;
            t.CdTraderPrecedente = ut.CdTraderPrecedente;
            t.CdMeseInizioFornitura = ut.CdStoricoMensileRete;
            t.DsClientStorico = ut.DsCliente;
            t.DsComune = ut.DsComune;
            t.CdComune = ut.CdComune;
            t.DsCliente = ut.DsCliente;
            t.IdStatoLavorazioneUtenza = ut.IdStato;
            t.CdAteco = ut.CdAteco;
            t.CdPrelievoAeeg = ut.CdPrelievoAeeg;
            t.CdPuntoFornitura = ut.CdPuntoFornitura;
            t.SAreaUscita = ut.SAreaUscita;
            t.ConsumoAnnuoStimato = ut.ConsumoAnnuoStimato;
            return t;
        }

        public static void MapVTPUserToSsh(VTpUtenzeAll vtp, SshUtenzeGasStorico ut)
        {
            ut.CdAteco = vtp.CdAteco;
            ut.CdCliente = vtp.CdCliente;
            ut.CdComune = vtp.CdComune;
            ut.CdPrelievoAeeg = vtp.CdPrelievoAeeg;
            ut.CdPuntoFornitura = vtp.CdPuntoFornitura;
            ut.ConsumoAnnuoStimato = vtp.ConsumoAnnuoStimato;
            ut.DsCliente = vtp.DsCliente;
            ut.IdStato = vtp.IdStato;
            ut.SAreaUscita = vtp.SAreaUscita;
        }
        public static void MapVTPUserToSsh(VList<VTpUtenzeAll> vtps, TList<SshUtenzeGasStorico> uts, params SshStatoRelazioniList[] exclude)
        {
            List<int> pList=new List<int>();
            foreach (SshStatoRelazioniList col in exclude)
                pList.Add((int)col);

            uts.Clear();
            foreach (VTpUtenzeAll vtp in vtps)
            {
                SshUtenzeGasStorico ut=new SshUtenzeGasStorico();
                MapVTPUserToSsh(vtp, ut);
                if (! pList.Contains(ut.IdStato??0))
                    uts.Add(ut);
            }
        }
        public static VTradersPrec MapPoolToVtradersPrec(VPool pool)
        {
            VTradersPrec tp = new VTradersPrec();
            tp.CdPool = pool.CdPool;
            tp.CdMeseInizioFornitura = pool.CdMeseInizioFornitura;
            tp.CdComune = pool.CdComune;
            return tp;
        }
        public static VShipperAttiviPool MapVSocietaStoricoToVShipperAttiviPool(VSocietaStorico soc)
        {
            VShipperAttiviPool sp = new VShipperAttiviPool();
            sp.CdPool = soc.CdPool;
            sp.CdSocieta = soc.CdSocieta;
            sp.CdStoricoMensileRete = soc.CdStoricoMensileRete;
            sp.DsSocieta = soc.DsSocieta;
            sp.Piva = soc.Piva;
            sp.TipologiaSocieta = soc.TipologiaSocieta;
            return sp;
        }
        public static VList<VShipperAttiviPool> MapVSocietaStoricoToVShipperAttiviPool(VList<VSocietaStorico> socl)
        {
            VList<VShipperAttiviPool> shl = new VList<VShipperAttiviPool>();
            foreach (VSocietaStorico soc in socl)
                shl.Add(MappingUtil.MapVSocietaStoricoToVShipperAttiviPool(soc));
            return shl;

        }
        public static VTradersPrec MapVSocietaStoricoToVTradersPrec(VSocietaStorico soc)
        {
            VTradersPrec tp = new VTradersPrec();
            tp.CdPool = soc.CdPool;
            tp.CdSocieta = soc.CdSocieta;
            tp.CdMeseInizioFornitura = soc.CdStoricoMensileRete;
            tp.DsSocieta = soc.DsSocieta;
            tp.Piva = soc.Piva;
            tp.TipologiaSocieta = soc.TipologiaSocieta;
            return tp;
        }
        public static VList<VTradersPrec> MapVSocietaStoricoToVTradersPrec(VList<VSocietaStorico> socl)
        {
            VList<VTradersPrec> shl = new VList<VTradersPrec>();
            foreach (VSocietaStorico soc in socl)
                shl.Add(MappingUtil.MapVSocietaStoricoToVTradersPrec(soc));
            return shl;

        }
        public static TList<SshTraderPrecStorico> MapTpToStorico(VList<VSimpleTraderPrec> tps)
        {
            TList<SshTraderPrecStorico> results = new TList<SshTraderPrecStorico>();
            foreach (VSimpleTraderPrec tp in tps)
                results.Add(MapToTpStorico(tp));

            return results;

        }
        public static SshTraderPrecStorico MapToTpStorico(VSimpleTraderPrec tp)
        {
            SshTraderPrecStorico result = new SshTraderPrecStorico();
            result.CdTraderPrecedente = tp.CdSocieta;
            result.RagioneSociale = tp.DsSocieta;
            result.MeseInizioFornitura = tp.CdStoricoMensileRete;

            return result;

        }
    }
}
